#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;
typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;
typedef float f32;
typedef double f64;
typedef char str;

#define __aligned(n) __attribute__((aligned(n)))
#define FORCE_TYPE_CONVERSION(x, type) (*(type *)&(x))
u32 f322u32(f32 value){
    union {
        f32 f;
        u32 i;
    }converter={.f=value};
    return converter.i;
}
f32 u322f32(u32 bits){
    union {
        f32 f;
        u32 i;
    }converter={.i=bits};
    return converter.f;
}

u64 f642u64(f64 value){
    union {
        f64 f;
        u64 i;
    }converter={.f=value};
    return converter.i;
}
f64 u642f64(u64 bits){
    union {
        f64 f;
        u64 i;
    }converter={.i=bits};
    return converter.f;
}

int main(int argc, char *argv[])
{
    short i = 18;
    if (argc < 2)
    {
        printf("Usage: %s <test_case_number>\n", argv[0]);
    }
    else
    {
        i = atoi(argv[1]);
    }
    switch (i)
    {
    case 1: // CTESTStart:1:91a779945b6da6b3ac13710b9cf48df7b93aeb05
    {
        typedef struct {
            u8 byteArray[10];
        } NestedStruct;
        typedef struct {
            str textField[22];
            NestedStruct nested;
        } MainTestStruct;
        MainTestStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

        strncpy(testValue->textField, "gaoshuaihugaoshuaihugaoshuaihu", sizeof(testValue->textField));
        memcpy(testValue->nested.byteArray, (u8[]){1,2,3}, 3);
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 2: // CTESTStart:2:8f191851439c496df279854cc7f0489e78bb4656
    {
        #pragma pack(push, 1)
        typedef struct {
            str emptyStr[10];
            u16 zeroArray[0];
        } EdgeCaseStruct;
        #pragma pack(pop)
        EdgeCaseStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

        strncpy(testValue->emptyStr, "", sizeof(testValue->emptyStr));
        const u16 flex_data[] = {};
        // 填充灵活数组成员
        memcpy((uint8_t*)testValue + sizeof(*testValue), flex_data, 0);

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 3: // CTESTStart:3:097b38c02d909218f160e1c2c99e6728834d4a63
    {
        typedef struct {
            f32 depth;
        } Level3;
        typedef struct __aligned(8) {
            Level3 l3;
        } Level2;
        #pragma pack(push, 4)
        typedef struct {
            Level2 l2;
        } Level1;
        #pragma pack(pop)
        Level1* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->l2.l3.depth = 3.14;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 4: // CTESTStart:4:28e74842409c4206134f8d8f594f16bf8d46b397
    {
        typedef struct {
            u16 num;
            i32 value;
        } EndianStruct;
        EndianStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->num = __builtin_bswap16(4661);
        testValue->value = __builtin_bswap32(1450744508);
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 5: // CTESTStart:5:df6f7bf60de1544b238231cf6e8748c6b225bdb5
    {
        #pragma pack(push, 4)
        typedef struct {
            u64 data;
        } Child;
        #pragma pack(pop)
        #pragma pack(push, 8)
        typedef struct {
            Child child;
            u32 counter;
        } ParentStruct;
        #pragma pack(pop)
        ParentStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->child.data = 1311768467294899695;
        testValue->counter = 4294967295;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 6: // CTESTStart:6:a1a2c7de231857cfa0f50dba9ede8f921e164b2a
    {
        typedef struct __aligned(128) {
            u8 flag;
            u64 reserved[16];
        } MaxAlignStruct;
        MaxAlignStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->flag = 1;
        memcpy(testValue->reserved, (u64[]){1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1}, 128);
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 7: // CTESTStart:7:ea849872fff6083f7fa1a67ddb2c693911a015c8
    {
        typedef struct {
            u16 num;
            u32 value;
        } EndianStruct;
        EndianStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->num = __builtin_bswap16(4660);
        testValue->value = __builtin_bswap32(1450744508);
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 8: // CTESTStart:8:196719eb3538062141530ccdc746cc275a9cf1d1
    {
        typedef struct {
            u16 num;
            u32 value;
        } EndianStruct;
        #pragma pack(push, 8)
        typedef struct __aligned(16) {
            u8 flag;
            u64 counters[2];
            EndianStruct nested;
        } CrossPlatformStruct;
        #pragma pack(pop)
        CrossPlatformStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->flag = 1;
        memcpy(testValue->counters, (u64[]){100,200}, 16);
        testValue->nested.num = 4660;
        testValue->nested.value = 1450744508;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 9: // CTESTStart:9:78ea41f2d0871da4ddef4eb23db19ebd3db4d214
    {
        typedef struct {
            u32 len;
            u16 data[0];
        } FlexibleArrayStruct;
        FlexibleArrayStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 6;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->len = 3;
        const u16 flex_data[] = {1,2,4};
        // 填充灵活数组成员
        memcpy((uint8_t*)testValue + sizeof(*testValue), flex_data, 6);

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 10: // CTESTStart:10:957ec380f6728aceb967bf31cdbefe10f31de78b
    {
        #pragma pack(push, 1)
        typedef struct {
            u16 a;
            u32 b;
        } InnerMost;
        #pragma pack(pop)
        #pragma pack(push, 4)
        typedef struct {
            u8 flag;
            InnerMost inner;
        } MiddleLayer;
        #pragma pack(pop)
        #pragma pack(push, 8)
        typedef struct __aligned(16) {
            MiddleLayer middle;
            u64 counter;
        } OuterStruct;
        #pragma pack(pop)
        OuterStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->middle.flag = 18;
        testValue->middle.inner.a = 43707;
        testValue->middle.inner.b = 3437096703;
        testValue->counter = 1234605616436508552;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 11: // CTESTStart:11:92aa6cf87e85a4bd0ee18b92df4cf22bb017c6c3
    {
        typedef struct __aligned(16) {
            __aligned(64) u8 dynamicArray[3];
            __aligned(8) u32 num;
        } FieldAlignStruct;
        FieldAlignStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                memcpy(testValue->dynamicArray, (u8[]){1,2,3}, 3);
        testValue->num = 3735928559;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 12: // CTESTStart:12:87b0a172f89df7f71d47e5a22c14ea1044a75e07
    {
        #pragma pack(push, 2)
        typedef struct {
            f32 floatVal;
            str text[20];
            i16 shortArray[4];
            u64 timestamp;
        } CompositeStruct;
        #pragma pack(pop)
        CompositeStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->floatVal = 3.141592653589793;
strncpy(testValue->text, "Hello 世界", sizeof(testValue->text));
        memcpy(testValue->shortArray, (i16[]){100,200,300,400}, 8);
        testValue->timestamp = 1747113192170;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 13: // CTESTStart:13:1a0c112e6a4e6959f5872ae54445aa8fcab34036
    {
        #pragma pack(push, 1)
        typedef struct __aligned(256) {
            u8 flag;
            __aligned(128) u32 alignedNum;
            __aligned(64) u16 numbers[3];
        } MaxAlignStruct;
        #pragma pack(pop)
        MaxAlignStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->flag = 255;
        testValue->alignedNum = 305419896;
        memcpy(testValue->numbers, (u16[]){1,2,3}, 6);
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 14: // CTESTStart:14:1549b42b1b1bf27ec877b54dbcf74d71766b654a
    {
        #pragma pack(push, 2)
        typedef struct {
            u8 a;
            u16 b;
            u32 c;
            u8 d;
        } CrossPlatform;
        #pragma pack(pop)
        CrossPlatform* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->a = 17;
        testValue->b = 8755;
        testValue->c = 1146447479;
        testValue->d = 136;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 15: // CTESTStart:15:1549b42b1b1bf27ec877b54dbcf74d71766b654a
    {
        #pragma pack(push, 2)
        typedef struct {
            u8 a;
            u16 b;
            u32 c;
            u8 d;
        } CrossPlatform;
        #pragma pack(pop)
        CrossPlatform* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->a = 17;
        testValue->b = __builtin_bswap16(8755);
        testValue->c = __builtin_bswap32(1146447479);
        testValue->d = 136;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 16: // CTESTStart:16:48257c707de6b09a6a2b2d2bc1e3ed8116cf60ba
    {
        #pragma pack(push, 1)
        typedef struct {
            u8 a;
            u32 b;
            u16 c;
        } TightPackingStruct;
        #pragma pack(pop)
        TightPackingStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->a = 1;
        testValue->b = 2864434397;
        testValue->c = 61183;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 17: // CTESTStart:17:0321f04d1c980553b4fd1d64d66e6875c690ec0a
    {
        #pragma pack(push, 2)
        typedef struct __aligned(8) {
            u16 arr[2];
        } InnerLayer;
        #pragma pack(pop)
        #pragma pack(push, 4)
        typedef struct {
            InnerLayer inner;
            __aligned(8) u8 flag;
        } MiddleLayer;
        #pragma pack(pop)
        #pragma pack(push, 8)
        typedef struct __aligned(16) {
            MiddleLayer middle;
            u64 counter;
        } OuterLayer;
        #pragma pack(pop)
        OuterLayer* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                memcpy(testValue->middle.inner.arr, (u16[]){4386,13124}, 4);
        testValue->middle.flag = 255;
        testValue->counter = 1311768467294899695;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 18: // CTESTStart:18:3120a026c3c5c92210df9a2ba5fce552021cf641
    {
        #pragma pack(push, 4)
        typedef struct {
            u16 id;
            u8 status;
        } ElementStruct;
        #pragma pack(pop)
        typedef struct __aligned(32) {
            ElementStruct elements[3];
            u32 checksum;
        } ArrayContainer;
        ArrayContainer* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->elements[0].id = 4660;
        testValue->elements[0].status = 170;
        testValue->elements[1].id = 4660;
        testValue->elements[1].status = 170;
        testValue->elements[2].id = 4660;
        testValue->elements[2].status = 170;
        testValue->checksum = 3735928559;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 19: // CTESTStart:19:bdbadf920fffaf088139fa557e921e22fba94c6a
    {
        #pragma pack(push, 4)
        typedef struct {
            f32 floatVal;
            __aligned(8) f64 doubleVal;
        } FloatTestStruct;
        #pragma pack(pop)
        FloatTestStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->floatVal = 123.456;
        testValue->doubleVal = 789.123;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 20: // CTESTStart:20:4c8ecca69725d0a28fe8b345420b2c77f2f5f1a0
    {
        #pragma pack(push, 1)
        typedef struct {
            u8 flags[4];
            __aligned(1) u8 status;
        } BitFieldStruct;
        #pragma pack(pop)
        BitFieldStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                memcpy(testValue->flags, (u8[]){1,0,1,1}, 4);
        testValue->status = 1;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 21: // CTESTStart:21:84d5ad0a2df4447b898f782835392b854b985894
    {
        #pragma pack(push, 4)
        typedef struct {
            u16 staticArray[5];
            u32 dynamicArray[0];
        } MixedArrayStruct;
        #pragma pack(pop)
        MixedArrayStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 12;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                memcpy(testValue->staticArray, (u16[]){1,2,3,4,5}, 10);
        const u32 flex_data[] = {6,7,8};
        // 填充灵活数组成员
        memcpy((uint8_t*)testValue + sizeof(*testValue), flex_data, 12);

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 22: // CTESTStart:22:41c7e381dc102edcfc80326704e9201449d69b4d
    {
        #pragma pack(push, 4)
        typedef struct {
            u8 a;
            u32 b;
            u16 c;
            u8 d;
        } FieldOrderStruct;
        #pragma pack(pop)
        FieldOrderStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->a = 1;
        testValue->b = 2864434397;
        testValue->c = 61183;
        testValue->d = 2;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 23: // CTESTStart:23:89f316ea3a026b1d53a0fc01d779efda79b92d44
    {
        typedef struct {
            u8 atom;
        } Level4;
        typedef struct __aligned(8) {
            Level4 child;
        } Level3;
        #pragma pack(push, 2)
        typedef struct {
            Level3 children[3];
        } Level2;
        #pragma pack(pop)
        typedef struct __aligned(16) {
            Level2 base;
        } Level1;
        Level1* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->base.children[0].child.atom = 255;
        testValue->base.children[1].child.atom = 255;
        testValue->base.children[2].child.atom = 255;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 24: // CTESTStart:24:b0f9dcc09966d8b555b2422f5d7c69657c077e72
    {
        #pragma pack(push, 4)
        typedef struct {
            u32 intVal;
            f32 floatVal;
        } UnionMember;
        #pragma pack(pop)
        #pragma pack(push, 1)
        typedef struct {
            u8 tag;
            UnionMember uniona;
        } UnionTestStruct;
        #pragma pack(pop)
        UnionTestStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->tag = 1;
        testValue->uniona.intVal = 305419896;
        testValue->uniona.floatVal = 123.456;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 25: // CTESTStart:25:d0ece10c45e36dab5ab2b722f22f6fb0267571bd
    {
        #pragma pack(push, 1)
        typedef struct {
            u8 status[3];
            __aligned(1) u8 enumVal;
        } BitFieldWithEnum;
        #pragma pack(pop)
        BitFieldWithEnum* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                memcpy(testValue->status, (u8[]){1,0,1}, 3);
        testValue->enumVal = 2;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 26: // CTESTStart:26:58eb061a40fe412cddfc17100e407f45161a1669
    {
        typedef struct {
            u32 len;
            u16 data[0];
        } DynamicFlexArray;
        DynamicFlexArray* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 10;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->len = 5;
        const u16 flex_data[] = {1,2,3,4,5};
        // 填充灵活数组成员
        memcpy((uint8_t*)testValue + sizeof(*testValue), flex_data, 10);

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 27: // CTESTStart:27:bb62499a24c6dd18143e7fc031229709c283c80d
    {
        typedef struct {
            i32 sysLong;
        } LongTestStruct;
        LongTestStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->sysLong = 305419896;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 28: // CTESTStart:28:e5ca2929a72f071a4530b186d63e276faf9c1a6c
    {
        #pragma pack(push, 8)
        typedef struct {
            u16 a;
            __aligned(4) u8 b;
            u32 c;
        } ComplexPadding;
        #pragma pack(pop)
        ComplexPadding* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->a = 43707;
        testValue->b = 204;
        testValue->c = 3723427601;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 29: // CTESTStart:29:52bd595f91f66300c6ed86ec3fadc3da857ae657
    {
        #pragma pack(push, 8)
        typedef struct {
            u64 maxVal;
            i64 minVal;
        } BigIntBoundary;
        #pragma pack(pop)
        BigIntBoundary* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->maxVal = 18446744073709551615;
        testValue->minVal = -9223372036854775808;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 30: // CTESTStart:30:d7e2171935616781c2a5b780142f64ebc671cebd
    {
        #pragma pack(push, 4)
        typedef struct {
            __aligned(16) u64 u64Array[3];
        } BigIntArray;
        #pragma pack(pop)
        BigIntArray* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                memcpy(testValue->u64Array, (u64[]){__builtin_bswap64(1234605616436508552),__builtin_bswap64(11072869122414935808),__builtin_bswap64(1311768467463790320)}, 24);
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 31: // CTESTStart:31:4e4933867434587eaf31aca316f8cb7fad0fca7a
    {
        typedef struct {
            u32 count;
            i64 data[0];
        } FlexBigIntArray;
        FlexBigIntArray* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 24;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->count = 3;
        const i64 flex_data[] = {9223372036854775807,-9223372036854775808,81985529216486895};
        // 填充灵活数组成员
        memcpy((uint8_t*)testValue + sizeof(*testValue), flex_data, 24);

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 32: // CTESTStart:32:99d3bc7444c0bf4edc0af7649f25ed27bbd721d0
    {
        #pragma pack(push, 8)
        typedef struct {
            str name[16];
            f64 ratio;
            u64 id;
        } MixedBigInt;
        #pragma pack(pop)
        MixedBigInt* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

        strncpy(testValue->name, "BigIntTest", sizeof(testValue->name));
        testValue->ratio = 3.141592653589793;
        testValue->id = 1311768467463790320;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 33: // CTESTStart:33:c1d0f35322a9426fce3e9c51cdd775479e0b508c
    {
        #pragma pack(push, 4)
        typedef struct {
            str chinese[20];
            str emoji[30];
        } UnicodeStruct;
        #pragma pack(pop)
        UnicodeStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

        strncpy(testValue->chinese, "中文测试", sizeof(testValue->chinese));
strncpy(testValue->emoji, "👍🚀🌟", sizeof(testValue->emoji));
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 34: // CTESTStart:34:1d486282977781ada7bdbde0f5e7c6506bef9985
    {
        typedef struct {
            u32 counter;
        } DynamicStruct;
        DynamicStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->counter = 3735928559;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 35: // CTESTStart:35:f56c15a7aca44656b69a4dd80fa74507d7d130d2
    {
        #pragma pack(push, 1)
        typedef struct {
            u8 flagA;
            u8 flagB;
            u8 flagC;
        } BitFlags;
        #pragma pack(pop)
        BitFlags* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->flagA = 1;
        testValue->flagB = 0;
        testValue->flagC = 1;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 36: // CTESTStart:36:f8623eb5abc588a7958086720608f13c130c10a2
    {
        typedef struct {
            u32 num;
            str text[10];
        } DefaultStruct;
        DefaultStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->num = 0;
strncpy(testValue->text, "", sizeof(testValue->text));
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 37: // CTESTStart:37:771a26cdd7794117f096a2772b7c92321df37a64
    {
        typedef struct {
            u32 value;
        } TerminalNode;
        typedef struct __aligned(8) {
            TerminalNode children[3];
        } MiddleNode;
        #pragma pack(push, 4)
        typedef struct {
            MiddleNode node;
        } RootNode;
        #pragma pack(pop)
        RootNode* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->node.children[0].value = 305419896;
        testValue->node.children[1].value = 305419896;
        testValue->node.children[2].value = 305419896;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 38: // CTESTStart:38:d8ebf5df4c1b7064b54e939d58c63701bd0369e8
    {
        typedef struct {
            u16 id;
        } CommonType;
        #pragma pack(push, 2)
        typedef struct {
            CommonType common;
        } ContainerA;
        #pragma pack(pop)
        ContainerA* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->common.id = 43981;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 39: // CTESTStart:39:d8ebf5df4c1b7064b54e939d58c63701bd0369e8
    {
        typedef struct {
            u16 id;
        } CommonType;
        typedef struct __aligned(8) {
            CommonType commons[2];
        } ContainerB;
        ContainerB* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->commons[0].id = 43981;
        testValue->commons[1].id = 43981;
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 40: // CTESTStart:40:be60e6bc11bb90618e74dbe91845885f87ba9a57
    {
        typedef struct {
            u16 arr[11];
        } NestedStruct;
        typedef struct {
            NestedStruct nested[0];
        } MainStruct;
        MainStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 44;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                memcpy(testValue->nested[0].arr, (u16[]){1,2,3}, 6);
        memcpy(testValue->nested[1].arr, (u16[]){1,2,3}, 6);
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 41: // CTESTStart:41:d60022f21068c9e9ce3a21f6668ed3d09c474cf0
    {
        #pragma pack(push, 1)
        typedef struct {
            str shortStr[5];
            str utf8Str[10];
        } StringTruncateStruct;
        #pragma pack(pop)
        StringTruncateStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 0;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

        strncpy(testValue->shortStr, "Hello World", sizeof(testValue->shortStr));
strncpy(testValue->utf8Str, "中文测试超长字符串", sizeof(testValue->utf8Str));
        // 填充灵活数组成员
        

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 42: // CTESTStart:42:9278ad97303b50a6a19c2636f8ed37f42778b1a1
    {
        typedef struct {
            u16 length;
            str autoStr[0];
        } AutoLengthStruct;
        AutoLengthStruct* testValue;

        // 内存分配与初始化
        size_t total_size = sizeof(*testValue) + 12;
        testValue = malloc(total_size);
        memset(testValue, 0, sizeof(*testValue));

                testValue->length = 12;
        const char flex_data[] = "Hello World";
        // 填充灵活数组成员
        memcpy((uint8_t*)testValue + sizeof(*testValue), flex_data, 12);

        // 输出内存字节流
        printf("[");
        for(size_t i=0; i<total_size; i++) {
            printf("%d%s", ((uint8_t*)testValue)[i], (i<total_size-1)?",":"");
        }
        printf("]");
        
        free(testValue);
    
    } // CTESTEnd
    break;
    case 43: // CTESTStart:43:23e073462c52d3e853789a1b561e004dd6305d84
    {
       
    } // CTESTEnd
    break;
    case 44: // CTESTStart:44:23e073462c52d3e853789a1b561e004dd6305d84
    {
       
    } // CTESTEnd
    break;
    }
}